import {
	cardDetail,
} from '@/api/extend.js'

export default {

	/**
	 * 进入我的名片判断
	 */

	toMyCardPage() {
		let myCard = uni.getStorageSync('userCardInfo');
		if (myCard && myCard.id > 0) {
			uni.navigateTo({
				url: '/pages/extend/connection/index_desc?id=' + myCard.id
			})
		} else {
			uni.showLoading({
				title: '加载中...'
			})
			cardDetail().then(res => {
				uni.hideLoading();
				if (res.status == 200 && res.data && res.data.id > 0) {
					uni.setStorageSync('userCardInfo', res.data);
					uni.navigateTo({
						url: '/pages/extend/connection/index_desc?id=' + res.data.id
					})
				} else {
					uni.navigateTo({
						url: '/pages/extend/connection/create?mode=edit'
					})
				}
			})
		}
	},

	/**
	 *	更具自定义导航栏跳转直定页面
	 */
	toNavigation(index = 0) {
		try {
			let navigation = uni.$store?.state?.extend?.navigation || {};
			let link = navigation?.menuList[index]?.link;
			uni.switchTab({
				url: link,
				fail() {
					uni.switchTab({
						url: '/pages/index/index'
					});
				}
			});
		} catch (e) {
			uni.switchTab({
				url: '/pages/index/index',
			});
		}

	},

	/**
	 * 从url 中提取key
	 * @param {Object} url
	 */
	getQueryParams(url) {
		// 创建一个空对象来存储参数
		const params = {};

		// 检查 URL 是否包含查询字符串
		if (url.indexOf('?') !== -1) {
			// 获取查询字符串部分
			const queryString = url.split('?')[1];

			// 将查询字符串按 '&' 分割成数组
			const paramPairs = queryString.split('&');

			// 遍历参数对数组
			paramPairs.forEach(pair => {
				// 将每个参数对按 '=' 分割成键和值
				const [key, value] = pair.split('=');

				// 将键和值存储到 params 对象中
				params[key] = decodeURIComponent(value);
			});
		}

		return params;
	},

	/**
	 * 判断是否为null
	 * 当第二个参数为 true时 0也为null
	 */
	isEmpty(value, treatZeroAsNull = false) {
		if (value === null || value === undefined) {
			return true;
		}
		if (treatZeroAsNull && value === 0) {
			return true;
		}
		if (typeof value === 'string' && value.trim() === '') {
			return true;
		}
		if (Array.isArray(value) && value.length === 0) {
			return true;
		}
		if (typeof value === 'object' && Object.keys(value).length === 0) {
			return true;
		}
		return false;
	},

	/**
	 * 隐私信息加密
	 * @param {Object} info
	 * @param {Object} type
	 */
	encryptSensitiveInfo(info, type) {
		if (!info) return '';
		switch (type) {
			case 'phone':
				return info.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
			case 'email':
				const [username, domain] = info.split('@');
				const hiddenUsername = username.slice(0, 3) + '****' + username.slice(-2);
				return hiddenUsername + '@' + domain;
			case 'wechat':
				return info.slice(0, 3) + '****' + info.slice(-1);
			case 'name':
				return info.charAt(0) + '****';
			default:
				throw new Error('Unsupported type');
		}
	},

	/**
	 * 字符串转数组
	 */
	strToArr(str, isHtt = true) {
		if (!str) return [];
		let arr = str.split(',');
		if (!Array.isArray(arr)) return [];

		if (isHtt) {
			arr.forEach((item, index, array) => {
				array[index] = this.ensureUrl(item);
			})
			return arr;
		} else {
			return arr;
		}

	},

	ensureUrl(input) {
		if (!input) return '';
		// 判断输入字符串是否以 http 或 https 开头
		if (input.startsWith('http://') || input.startsWith('https://')) {
			return input;
		} else {
			// 如果没有，则添加 https://yjgs.jsonbug.com/
			return 'https://yjgs.jsonbug.com' + input;
		}
	},

	preView(list, index = 0) {
		uni.previewImage({
			urls: list,
			current: index
		})
	},

	/**
	 * 2个时间做比较 是否过期
	 * @param {Object} currentDate 2024-10-10 15:35:13
	 * @param {Object} membershipEndDate 2024-10-10 15:35:13
	 */
	isMembershipExpired(currentDate, membershipEndDate) {
		// 将日期字符串转换为 Date 对象
		const currentDateTime = new Date(currentDate);
		const membershipEndDateTime = new Date(membershipEndDate);

		// 比较两个日期
		if (currentDateTime > membershipEndDateTime) {
			return true; // 会员已过期
		} else {
			return false; // 会员未过期
		}
	},

	formatTime(dateTime = null, formatStr = 'yyyy-mm-dd') {
		let date
		// 若传入时间为假值，则取当前时间
		if (!dateTime) {
			date = new Date()
		}
		// 若为unix秒时间戳，则转为毫秒时间戳（逻辑有点奇怪，但不敢改，以保证历史兼容）
		else if (/^\d{10}$/.test(dateTime?.toString().trim())) {
			date = new Date(dateTime * 1000)
		}
		// 若用户传入字符串格式时间戳，new Date无法解析，需做兼容
		else if (typeof dateTime === 'string' && /^\d+$/.test(dateTime.trim())) {
			date = new Date(Number(dateTime))
		}
		// 处理平台性差异，在Safari/Webkit中，new Date仅支持/作为分割符的字符串时间
		// 处理 '2022-07-10 01:02:03'，跳过 '2022-07-10T01:02:03'
		else if (typeof dateTime === 'string' && dateTime.includes('-') && !dateTime.includes('T')) {
			date = new Date(dateTime.replace(/-/g, '/'))
		}
		// 其他都认为符合 RFC 2822 规范
		else {
			date = new Date(dateTime)
		}

		const timeSource = {
			'y': date.getFullYear().toString(), // 年
			'm': (date.getMonth() + 1).toString().padStart(2, '0'), // 月
			'd': date.getDate().toString().padStart(2, '0'), // 日
			'h': date.getHours().toString().padStart(2, '0'), // 时
			'M': date.getMinutes().toString().padStart(2, '0'), // 分
			's': date.getSeconds().toString().padStart(2, '0') // 秒
			// 有其他格式化字符需求可以继续添加，必须转化成字符串
		}

		for (const key in timeSource) {
			const [ret] = new RegExp(`${key}+`).exec(formatStr) || []
			if (ret) {
				// 年可能只需展示两位
				const beginIndex = key === 'y' && ret.length === 2 ? 2 : 0
				formatStr = formatStr.replace(ret, timeSource[key].slice(beginIndex))
			}
		}

		return formatStr
	},

	/**
	 * 传入时间返回多久前
	 * 比如 传入 2024-09-22 16:09:35 返回 刚刚 1分钟前
	 */
	timeToHow(dateString) {
		if (!dateString) return '未知';
		const date = new Date(dateString);
		const now = new Date();
		const diff = now - date; // 计算时间差，单位是毫秒

		const seconds = Math.floor(diff / 1000);
		const minutes = Math.floor(seconds / 60);
		const hours = Math.floor(minutes / 60);
		const days = Math.floor(hours / 24);
		const months = Math.floor(days / 30);
		const years = Math.floor(months / 12);

		if (years > 0) {
			return `${years}年前`;
		} else if (months > 0) {
			return `${months}个月前`;
		} else if (days > 0) {
			return `${days}天前`;
		} else if (hours > 0) {
			return `${hours}小时前`;
		} else if (minutes > 0) {
			return `${minutes}分钟前`;
		} else {
			return `${seconds < 0 ? '1' : seconds}秒前`;
		}
	}

}